//DOM-IGNORE-BEGIN
/*
Copyright (C) 2025, Microchip Technology Inc., and its subsidiaries. All rights reserved.

The software and documentation is provided by microchip and its contributors
"as is" and any express, implied or statutory warranties, including, but not
limited to, the implied warranties of merchantability, fitness for a particular
purpose and non-infringement of third party intellectual property rights are
disclaimed to the fullest extent permitted by law. In no event shall microchip
or its contributors be liable for any direct, indirect, incidental, special,
exemplary, or consequential damages (including, but not limited to, procurement
of substitute goods or services; loss of use, data, or profits; or business
interruption) however caused and on any theory of liability, whether in contract,
strict liability, or tort (including negligence or otherwise) arising in any way
out of the use of the software and documentation, even if advised of the
possibility of such damage.

Except as expressly permitted hereunder and subject to the applicable license terms
for any third-party software incorporated in the software and any a pplicable open
source software license terms, no license or other rights, whether express or
implied, are granted under any patent or other intellectual property rights of
Microchip or any third party.
*/
//DOM-IGNORE-END

#include "../test_vectors_sha256.h"

/* 
 The following test vectors were pulled from NIST's Secure Hash Standard (SHS) FIPS 180-4 validation: 
 https://csrc.nist.gov/projects/cryptographic-algorithm-validation-program/secure-hashing
*/ 


// SHA-256 0 Bytes Test Vector
static uint8_t sha_256_0_bytes_digest[SHA256_DIGEST_LEN_BYTES] = {
    0xE3, 0xB0, 0xC4, 0x42, 0x98, 0xFC, 0x1C, 0x14, 0x9A, 0xFB, 0xF4, 0xC8, 0x99, 0x6F, 0xB9, 0x24,
    0x27, 0xAE, 0x41, 0xE4, 0x64, 0x9B, 0x93, 0x4C, 0xA4, 0x95, 0x99, 0x1B, 0x78, 0x52, 0xB8, 0x55
};
static const TEST_VECTOR sha_256_0_bytes_vector = {
    (uint8_t*) 0, 
    0,
    (uint8_t*) &sha_256_0_bytes_digest
};

// SHA-256 35 Bytes Test Vector
static uint8_t sha_256_35_bytes[35] = {
    0xE6, 0x8C, 0xB6, 0xD8, 0xC1, 0x86, 0x6C, 0x0A, 0x71, 0xE7, 0x31, 0x3F, 0x83, 
    0xDC, 0x11, 0xA5, 0x80, 0x9C, 0xF5, 0xCF, 0xBE, 0xED, 0x1A, 0x58, 0x7C, 0xE9, 
    0xC2, 0xC9, 0x2E, 0x02, 0x2A, 0xBC, 0x16, 0x44, 0xBB
};
static uint8_t sha_256_35_bytes_digest[SHA256_DIGEST_LEN_BYTES] = {
    0xc2, 0x68, 0x4c, 0x0d, 0xbb, 0x85, 0xc2, 0x32, 0xb6, 0xda, 0x4f, 0xb5, 0x14,
    0x7d, 0xd0, 0x62, 0x44, 0x29, 0xec, 0x7e, 0x65, 0x79, 0x91, 0xed, 0xd9, 0x5e,
    0xda, 0x37, 0xa5, 0x87, 0x26, 0x9e
};
static const TEST_VECTOR sha_256_35_bytes_vector = {
    (uint8_t*) &sha_256_35_bytes, 
    sizeof(sha_256_35_bytes),
    (uint8_t*) &sha_256_35_bytes_digest
};

// SHA-256 41 Bytes Test Vector
static uint8_t sha_256_41_bytes[41] = {
    0x6A, 0xC6, 0xC6, 0x3D, 0x61, 0x8E, 0xAF, 0x00, 0xD9, 0x1C, 0x5E, 0x28, 0x07, 
    0xE8, 0x3C, 0x09, 0x39, 0x12, 0xB8, 0xE2, 0x02, 0xF7, 0x8E, 0x13, 0x97, 0x03, 
    0x49, 0x8A, 0x79, 0xC6, 0x06, 0x7F, 0x54, 0x49, 0x7C, 0x61, 0x27, 0xA2, 0x39, 
    0x10, 0xA6
};
static uint8_t sha_256_41_bytes_digest[SHA256_DIGEST_LEN_BYTES] = {
    0x4B, 0xB3, 0x3E, 0x7C, 0x69, 0x16, 0xE0, 0x8A, 0x9B, 0x3E, 0xD6, 0xBC, 0xEF, 
    0x79, 0x0A, 0xAA, 0xEE, 0x0D, 0xCF, 0x2E, 0x7A, 0x01, 0xAF, 0xB0, 0x56, 0x18, 
    0x2D, 0xEA, 0x2D, 0xAD, 0x7D, 0x63
};
static const TEST_VECTOR sha_256_41_bytes_vector = {
    (uint8_t*) &sha_256_41_bytes, 
    sizeof(sha_256_41_bytes),
    (uint8_t*) &sha_256_41_bytes_digest
};

// SHA-256 48 Bytes Test Vector
static uint8_t sha_256_48_bytes[48] = {
    0x4E, 0xEF, 0x51, 0x07, 0x45, 0x9B, 0xDD, 0xF8, 0xF2, 0x4F, 0xC7, 0x65, 0x6F, 
    0xD4, 0x89, 0x6D, 0xA8, 0x71, 0x1D, 0xB5, 0x04, 0x00, 0xC0, 0x16, 0x48, 0x47, 
    0xF6, 0x92, 0xB8, 0x86, 0xCE, 0x8D, 0x7F, 0x4D, 0x67, 0x39, 0x50, 0x90, 0xB3, 
    0x53, 0x4E, 0xFD, 0x7B, 0x0D, 0x29, 0x8D, 0xA3, 0x4B
};
static uint8_t sha_256_48_bytes_digest[SHA256_DIGEST_LEN_BYTES] = {
    0x7C, 0x5D, 0x14, 0xED, 0x83, 0xDA, 0xB8, 0x75, 0xAC, 0x25, 0xCE, 0x7F, 0xEE, 
    0xD6, 0xEF, 0x83, 0x7D, 0x58, 0xE7, 0x9D, 0xC6, 0x01, 0xFB, 0x3C, 0x1F, 0xCA, 
    0x48, 0xD4, 0x46, 0x4E, 0x8B, 0x83
};
static const TEST_VECTOR sha_256_48_bytes_vector = {
    (uint8_t*) &sha_256_48_bytes, 
    sizeof(sha_256_48_bytes),
    (uint8_t*) &sha_256_48_bytes_digest
};

// SHA-256 64 Bytes Test Vector
static uint8_t sha_256_64_bytes[64] = {
    0x60, 0xF0, 0x1E, 0x1F, 0xFA, 0x5A, 0xF0, 0xDF, 0x6C, 0x5A, 0xED, 0x19, 0x0D, 0x2F, 0x7F, 0x4D,
    0x37, 0xEC, 0x39, 0xF3, 0xF8, 0xA5, 0x17, 0x32, 0x41, 0x09, 0x2C, 0x3D, 0x42, 0x71, 0xCA, 0x8C,
    0x22, 0xAF, 0x0C, 0x59, 0xFA, 0x87, 0x24, 0xA7, 0x49, 0x00, 0xFF, 0x1D, 0x0E, 0x3C, 0xB9, 0x00,
    0x0D, 0x49, 0x26, 0xA6, 0x7D, 0xB9, 0x93, 0x6D, 0x49, 0x18, 0xA7, 0x1E, 0x01, 0x3A, 0xE0, 0x6C
};
static uint8_t sha_256_64_bytes_digest[SHA256_DIGEST_LEN_BYTES] = {
    0xF0, 0xD9, 0xC1, 0xBE, 0x0A, 0xF7, 0xF2, 0xE1, 0xA5, 0xBE, 0x89, 0x4E, 0x7A, 0x3F, 0x92, 0xA6,
    0x48, 0x0B, 0x86, 0x1E, 0xF4, 0x6C, 0xAC, 0x5E, 0xD3, 0x0D, 0x58, 0xBD, 0xE8, 0x6D, 0x91, 0xB6
};
static const TEST_VECTOR sha_256_64_bytes_vector = {
    (uint8_t*) &sha_256_64_bytes, 
    sizeof(sha_256_64_bytes),
    (uint8_t*) &sha_256_64_bytes_digest
};

// SHA-256 128 Bytes Test Vector
static uint8_t sha_256_128_bytes[128] = {
    0xB0, 0xDF, 0x56, 0x23, 0xCE, 0x7E, 0x51, 0x88, 0xC7, 0x4B, 0xF1, 0x30, 0x2A, 0x29, 0xED, 0x48,
    0xAD, 0xFC, 0x5C, 0x7A, 0x62, 0xA2, 0x86, 0x0B, 0xCF, 0x15, 0x3B, 0xA6, 0xFE, 0xA8, 0xC4, 0x75,
    0x5B, 0x58, 0xDC, 0x20, 0x1B, 0x6F, 0x0D, 0xC8, 0xF2, 0x9D, 0x6F, 0xF3, 0x69, 0x46, 0x06, 0x66,
    0xE9, 0xDF, 0xBE, 0x1E, 0xB7, 0x88, 0xB5, 0x8D, 0xFF, 0x71, 0x93, 0xDB, 0x46, 0x43, 0x25, 0x37,
    0x3E, 0x5A, 0x76, 0x30, 0x8F, 0xD7, 0x27, 0x6C, 0x1A, 0x13, 0x02, 0x18, 0x2F, 0x86, 0x7D, 0x62,
    0xF1, 0x82, 0xEA, 0x23, 0xDF, 0x02, 0xCF, 0xD1, 0x89, 0x6C, 0xF7, 0x43, 0xDC, 0x27, 0xDB, 0xF4,
    0xB5, 0x9E, 0x79, 0xE6, 0xA8, 0xF8, 0xE8, 0xD4, 0x02, 0x9E, 0x20, 0x87, 0x5A, 0x3E, 0xFA, 0xF7,
    0xB5, 0x6F, 0x03, 0x22, 0x38, 0xDB, 0xD5, 0xB7, 0x41, 0x1F, 0x28, 0x78, 0xAB, 0x2A, 0x0B, 0x3B
};
static uint8_t sha_256_128_bytes_digest[SHA256_DIGEST_LEN_BYTES] = {
    0x52, 0x1A, 0x7B, 0x4F, 0xD5, 0x3D, 0x6B, 0x26, 0xE4, 0xF5, 0x79, 0x81, 0x5B, 0x9B, 0xD9, 0x96,
    0x10, 0x83, 0x32, 0x6F, 0x5C, 0xB3, 0xBE, 0x45, 0xE2, 0x69, 0xDD, 0x5E, 0xD5, 0xE3, 0xA2, 0x83
};
static const TEST_VECTOR sha_256_128_bytes_vector = {
    (uint8_t*) &sha_256_128_bytes, 
    sizeof(sha_256_128_bytes),
    (uint8_t*) &sha_256_128_bytes_digest
};

// SHA-256 512 Bytes Test Vector
static uint8_t sha_256_512_bytes[512] = {
    0xE0, 0x11, 0x3A, 0x46, 0x3D, 0xC4, 0x23, 0x96, 0xBF, 0xF8, 0x99, 0xD4, 0xCC, 0xB7, 0x54, 0x03,
    0xDC, 0x79, 0xA7, 0x17, 0x6E, 0x2B, 0xCD, 0xEF, 0xC3, 0x16, 0x51, 0x69, 0x39, 0x2B, 0xC2, 0x36,
    0xB5, 0xA8, 0x52, 0x2E, 0x8C, 0x66, 0xCE, 0xEE, 0xEA, 0xAA, 0x5D, 0x70, 0x58, 0x32, 0xAA, 0x53,
    0xC8, 0xFC, 0x26, 0x8E, 0x2C, 0x51, 0xE9, 0x33, 0x40, 0xC7, 0xAC, 0x0C, 0xB3, 0x0D, 0x40, 0x1D,
    0x68, 0xF2, 0x07, 0x76, 0x0B, 0x1D, 0xFF, 0x02, 0x07, 0xD4, 0x69, 0x57, 0x5E, 0x0E, 0xB7, 0x70,
    0x22, 0x05, 0x77, 0x7A, 0x48, 0x2B, 0x28, 0xBD, 0x1F, 0x5E, 0x4C, 0x8C, 0x69, 0xD6, 0xC3, 0x53,
    0x02, 0xBB, 0x7E, 0x10, 0xA3, 0xCD, 0x58, 0x40, 0x76, 0x6F, 0xB9, 0x55, 0x0F, 0x09, 0x91, 0x8C,
    0x54, 0x16, 0xE2, 0x77, 0x61, 0x42, 0xD9, 0xE7, 0x02, 0xAA, 0x43, 0x64, 0x5D, 0x76, 0x72, 0xC1,
    0x29, 0x78, 0x61, 0xEF, 0x9B, 0x0B, 0x86, 0x05, 0x7C, 0xD9, 0xBD, 0x21, 0x12, 0x2B, 0x68, 0x63,
    0xC2, 0xA9, 0x03, 0xDB, 0x98, 0xEC, 0xCC, 0x63, 0xAB, 0x19, 0x1C, 0x29, 0xD2, 0xD5, 0x19, 0x34,
    0x90, 0xCC, 0x80, 0x77, 0x6D, 0x53, 0x36, 0x57, 0xF2, 0x7A, 0x63, 0x2D, 0xA6, 0x84, 0x01, 0x1E,
    0xD4, 0x16, 0x39, 0x77, 0xAA, 0x02, 0x8E, 0xA9, 0xF0, 0xCE, 0x43, 0xD1, 0x63, 0x78, 0x7F, 0xE0,
    0x06, 0x63, 0xA6, 0x13, 0x49, 0x3D, 0x79, 0xFB, 0x21, 0xAE, 0xDE, 0x26, 0x96, 0xBC, 0x31, 0xEE,
    0xEB, 0x7F, 0xA2, 0x52, 0xB5, 0x20, 0x97, 0x36, 0xE0, 0xC9, 0xB5, 0xE6, 0x4F, 0x58, 0x05, 0xD0,
    0xA1, 0xFA, 0xEA, 0xD7, 0x73, 0xEC, 0x9D, 0x77, 0x68, 0xEF, 0x97, 0x42, 0x39, 0x6F, 0x73, 0xA5,
    0xB5, 0x92, 0x29, 0x69, 0x49, 0x20, 0xDA, 0xF1, 0x3B, 0x19, 0x00, 0xE7, 0xB5, 0xE1, 0xEB, 0xB9,
    0xF0, 0x18, 0x95, 0x09, 0x62, 0xE6, 0x81, 0x15, 0xE9, 0xEC, 0x73, 0x90, 0x11, 0xD3, 0x50, 0xE1,
    0xB0, 0x6B, 0xC8, 0x3B, 0x11, 0xF6, 0xE9, 0x36, 0x04, 0x4C, 0xBE, 0xF4, 0x02, 0x86, 0x64, 0xDB,
    0x80, 0xA9, 0x15, 0x8A, 0x50, 0x24, 0x11, 0x7D, 0xCD, 0x3B, 0x5F, 0x32, 0x57, 0xDE, 0x3D, 0xFA,
    0x0E, 0x03, 0x6E, 0x19, 0xBD, 0x6B, 0x62, 0x06, 0xA2, 0xE6, 0x2E, 0x73, 0x64, 0x4F, 0x50, 0x48,
    0x1F, 0xCA, 0x6F, 0x4F, 0xCD, 0x5F, 0xE4, 0x1F, 0x84, 0x86, 0xA7, 0x74, 0xFC, 0x8B, 0x1C, 0x32,
    0xC0, 0x22, 0x43, 0x53, 0xCF, 0x83, 0xA6, 0xEF, 0xF8, 0xE2, 0xE9, 0x35, 0x43, 0x95, 0x03, 0x74,
    0xAF, 0x5B, 0xBE, 0x74, 0x11, 0xFD, 0x1C, 0x52, 0x56, 0x3D, 0x9D, 0x63, 0x5B, 0x5B, 0xE8, 0x8C,
    0x1B, 0x71, 0x09, 0x68, 0xC3, 0x00, 0xA4, 0xDE, 0x3F, 0x80, 0x4D, 0xEA, 0xB2, 0x3B, 0x5C, 0x22,
    0xE9, 0x02, 0xCF, 0xE5, 0x18, 0x38, 0xA4, 0xC9, 0x8A, 0x07, 0x53, 0x74, 0x62, 0xE5, 0x6F, 0x45,
    0xCC, 0x9B, 0x70, 0xA0, 0xB8, 0xED, 0x77, 0x7E, 0x41, 0xD7, 0xAC, 0xB5, 0xC7, 0xA7, 0x5A, 0xA9,
    0xB2, 0xFF, 0x48, 0xCA, 0xA0, 0xB5, 0x28, 0x8B, 0x12, 0xC1, 0x55, 0x3A, 0x7E, 0xE5, 0xB5, 0xEC,
    0x35, 0x14, 0x91, 0x0C, 0xE4, 0x0E, 0x22, 0x32, 0xCC, 0x70, 0x9B, 0x40, 0xC3, 0xB6, 0x8B, 0xE0,
    0x42, 0xD2, 0x5A, 0x17, 0xD1, 0xA4, 0x5A, 0x5E, 0xA8, 0x55, 0xAF, 0xDA, 0x1F, 0x43, 0xEE, 0xDC,
    0x18, 0x70, 0x6B, 0x52, 0x88, 0x9C, 0x7B, 0x0C, 0x17, 0x1A, 0x6F, 0xFB, 0x14, 0xD0, 0xE0, 0xC1,
    0x9C, 0x75, 0x7E, 0x6D, 0xC2, 0xCD, 0x5C, 0xA1, 0x66, 0x1A, 0xA9, 0x60, 0x1B, 0x3A, 0x4C, 0x3C,
    0x6B, 0xAF, 0x11, 0xA4, 0x77, 0x27, 0x55, 0xC1, 0x3F, 0x1C, 0xE5, 0x2E, 0x46, 0xC1, 0x79, 0x51
};
static uint8_t sha_256_512_bytes_digest[SHA256_DIGEST_LEN_BYTES] = {
    0x57, 0xAF, 0xC3, 0x53, 0x58, 0x72, 0x3C, 0x81, 0x60, 0x13, 0x3D, 0x41, 0x19, 0xB0, 0xFC, 0x85,
    0x92, 0x92, 0x52, 0xA4, 0x87, 0x4C, 0xDC, 0x49, 0x45, 0x2D, 0x5A, 0x0A, 0x13, 0x89, 0xCA, 0x24
};

static const TEST_VECTOR sha_256_512_bytes_vector = {
    (uint8_t*) &sha_256_512_bytes, 
    sizeof(sha_256_512_bytes),
    (uint8_t*) &sha_256_512_bytes_digest
};

// SHA-256 835 Bytes Test Vector
static uint8_t sha_256_835_bytes[835] = {
    0x64, 0x3d, 0xbb, 0xc6, 0xd0, 0xff, 0x34, 0x9e, 0xb7, 0x74, 0xae, 0x83, 0x83, 0x3d, 0xd2, 0x65,
    0x75, 0x07, 0x0e, 0xe4, 0xa2, 0x42, 0xe7, 0x7e, 0x86, 0x22, 0xb0, 0x3b, 0x6e, 0xc3, 0x4f, 0x1c,
    0x9c, 0x03, 0x19, 0x6d, 0x53, 0x88, 0xfd, 0x2e, 0x47, 0x9e, 0x45, 0x0d, 0x2b, 0xa3, 0x0c, 0xdb,
    0xf9, 0xe1, 0x3c, 0xb3, 0x8f, 0x9d, 0xfb, 0x7d, 0xaa, 0x0f, 0x4e, 0xcd, 0x2d, 0x7c, 0x3d, 0xfd,
    0x81, 0xd9, 0x26, 0x8f, 0x18, 0xcc, 0x47, 0xb2, 0xba, 0x9d, 0x82, 0x9d, 0xc0, 0x92, 0x8d, 0xd4,
    0xef, 0xde, 0xb7, 0xab, 0xc0, 0xd0, 0xf6, 0xc2, 0x93, 0x32, 0x39, 0x9a, 0x3a, 0xb8, 0xcc, 0xc9,
    0x3c, 0x06, 0x9f, 0xb9, 0x78, 0xfb, 0xb9, 0xb0, 0x8d, 0xfd, 0x83, 0x85, 0x5f, 0x8e, 0xb0, 0xe4,
    0xaa, 0x88, 0x85, 0xfa, 0x45, 0x79, 0x03, 0x20, 0x92, 0x9e, 0x8b, 0xd2, 0x7d, 0xd4, 0xaf, 0x3e,
    0x22, 0xe1, 0x2c, 0x70, 0x76, 0x38, 0x5d, 0x74, 0xd8, 0xfd, 0x24, 0xc3, 0xf0, 0x88, 0x60, 0x1f,
    0x04, 0xb6, 0x6f, 0xe9, 0xf6, 0xee, 0xab, 0x68, 0x76, 0x15, 0xf1, 0xd5, 0x70, 0x92, 0xad, 0xb2,
    0xc1, 0x73, 0x0e, 0xc0, 0xad, 0xb4, 0x9a, 0x1a, 0x72, 0x7b, 0xe8, 0xf1, 0xe2, 0x7a, 0x35, 0x84,
    0x74, 0xfc, 0x64, 0x2b, 0x87, 0x70, 0xb1, 0x30, 0xa2, 0xd9, 0x25, 0x10, 0x52, 0xd0, 0xf0, 0xc1,
    0xee, 0x07, 0x3e, 0x26, 0x0d, 0xd5, 0x1b, 0x68, 0xe1, 0xf7, 0x5a, 0xa8, 0x1f, 0x4e, 0x42, 0x9c,
    0x26, 0x44, 0xa5, 0x61, 0x53, 0x9b, 0xb9, 0xff, 0x9a, 0x1b, 0x96, 0xc9, 0x1d, 0x7c, 0x11, 0xcd,
    0x23, 0x08, 0x3f, 0x24, 0x16, 0x5c, 0xc8, 0x1a, 0x5d, 0xb7, 0xc6, 0x40, 0x70, 0x4c, 0x4b, 0x38,
    0xa3, 0x42, 0x8d, 0x64, 0x9d, 0x13, 0xc9, 0x2d, 0x2b, 0x54, 0x82, 0xd5, 0xef, 0x79, 0x20, 0xa8,
    0x37, 0xcb, 0xf4, 0x6b, 0x86, 0xe5, 0xde, 0xb3, 0xa8, 0x43, 0x74, 0x1c, 0xc9, 0xe5, 0x54, 0x1c,
    0xf0, 0x85, 0x42, 0x3d, 0x24, 0x49, 0x98, 0x17, 0x73, 0xc6, 0x0a, 0xf5, 0x0f, 0x70, 0x5d, 0xd2,
    0xd4, 0x90, 0x26, 0xc4, 0x69, 0x3c, 0xbe, 0xe6, 0x7f, 0xb1, 0xad, 0x36, 0x2b, 0x3d, 0xf3, 0x36,
    0x4a, 0x92, 0x45, 0x4d, 0x4c, 0xf4, 0x38, 0x5e, 0x8f, 0x5d, 0xa7, 0x45, 0xcb, 0x5e, 0x65, 0x55,
    0x7a, 0xa0, 0x5a, 0xbc, 0x1b, 0x9e, 0xaf, 0x36, 0xd2, 0x8f, 0x31, 0x5d, 0xa7, 0x28, 0x75, 0x1a,
    0x0b, 0xd6, 0x54, 0x74, 0xc5, 0xd7, 0x72, 0x2e, 0x4d, 0x42, 0x62, 0x18, 0x72, 0x91, 0x75, 0xb1,
    0x0f, 0x54, 0x5e, 0xa0, 0x58, 0xff, 0x0c, 0x9e, 0x07, 0x0b, 0x25, 0xbe, 0x22, 0x86, 0xa0, 0xf2,
    0x76, 0x19, 0xd6, 0x41, 0x10, 0x74, 0xaa, 0xd8, 0x40, 0xb2, 0xbc, 0x28, 0x3c, 0xb6, 0x41, 0xf8,
    0x4d, 0x54, 0xe3, 0x47, 0x1a, 0xeb, 0x34, 0xe2, 0x17, 0x64, 0xe9, 0x70, 0xb0, 0xb3, 0xe0, 0x09,
    0x6a, 0x9f, 0xce, 0xb3, 0x89, 0xc2, 0x06, 0xf3, 0x9c, 0x79, 0x8c, 0x8c, 0xe1, 0x23, 0x03, 0xf0,
    0x7b, 0xd6, 0x72, 0x03, 0x8f, 0x0a, 0x92, 0x44, 0xcd, 0x5f, 0x03, 0x16, 0x68, 0x47, 0x52, 0xcd,
    0x3e, 0x9d, 0x4b, 0x40, 0xa7, 0xbd, 0xce, 0xbf, 0x58, 0x73, 0x52, 0xad, 0x30, 0x02, 0x42, 0x1b,
    0x7b, 0x52, 0xb7, 0x03, 0x80, 0x1f, 0xa6, 0xb6, 0xdf, 0x75, 0x71, 0x57, 0x82, 0x5e, 0x66, 0xef,
    0x26, 0xbc, 0x8f, 0x23, 0x3e, 0x7e, 0x42, 0x33, 0xd9, 0xf2, 0x22, 0x36, 0xc0, 0x71, 0xba, 0x3e,
    0xb7, 0x86, 0x75, 0xcf, 0x36, 0x79, 0x8a, 0xcd, 0xc0, 0x8a, 0xbe, 0xea, 0xf0, 0xa7, 0xb2, 0x7a,
    0xa9, 0x13, 0x1e, 0xeb, 0x41, 0xf9, 0xa2, 0xf1, 0x21, 0xee, 0x7d, 0x0a, 0xed, 0x67, 0x41, 0x9e,
    0x5f, 0x61, 0xff, 0x35, 0xd9, 0x10, 0x03, 0x45, 0xa8, 0xd0, 0x1c, 0xe1, 0x70, 0x64, 0x21, 0x57,
    0xfd, 0x0f, 0x9d, 0x02, 0x10, 0x1a, 0x9f, 0xb6, 0xbc, 0x4f, 0xdf, 0x3a, 0xbf, 0x32, 0x9e, 0xdd,
    0x6c, 0x2f, 0x4e, 0x11, 0xff, 0xaf, 0x8a, 0x46, 0x15, 0x2e, 0x05, 0xe1, 0xb0, 0x5e, 0x40, 0x00,
    0x28, 0x3c, 0x3c, 0x8b, 0x44, 0xad, 0xcd, 0xae, 0x72, 0xfe, 0xe5, 0x64, 0x56, 0x18, 0x74, 0xae,
    0xb1, 0xcd, 0x3f, 0xb0, 0x65, 0x49, 0x94, 0x3a, 0x9b, 0xe2, 0xaf, 0xdd, 0xc9, 0x12, 0xb5, 0xa1,
    0xb4, 0x36, 0x52, 0x33, 0xe0, 0x4f, 0xaa, 0xab, 0xe0, 0xb3, 0x5b, 0x93, 0xea, 0x26, 0x28, 0xc5,
    0x0c, 0xcf, 0xf3, 0x65, 0x00, 0xf4, 0x37, 0x7b, 0x70, 0x1d, 0xda, 0xef, 0x58, 0xad, 0x61, 0xce,
    0x91, 0xcf, 0x8a, 0x7f, 0xde, 0x80, 0x7d, 0xa5, 0x33, 0x3f, 0xa5, 0x9c, 0xc5, 0x04, 0x57, 0x76,
    0xd1, 0x08, 0x8b, 0x2b, 0xe1, 0x46, 0x71, 0x3e, 0xb5, 0x31, 0xb4, 0x5d, 0xf4, 0xdd, 0xeb, 0x85,
    0x4f, 0x21, 0x97, 0x41, 0x9c, 0xfa, 0xcd, 0x97, 0xfa, 0xd4, 0xac, 0x71, 0x33, 0xec, 0xac, 0x24,
    0x7a, 0xcf, 0xcd, 0x44, 0x33, 0xb1, 0xef, 0x28, 0x10, 0x26, 0x79, 0xab, 0x18, 0x77, 0x7a, 0xdf,
    0xb1, 0xd9, 0x89, 0x72, 0x28, 0xd1, 0x45, 0x9e, 0x4c, 0xbe, 0xdc, 0xd0, 0x6f, 0x82, 0x65, 0x2f,
    0xdc, 0xcc, 0xd4, 0x6e, 0xbd, 0x9c, 0x5f, 0xd8, 0x93, 0xc0, 0x12, 0xe1, 0x99, 0x19, 0x56, 0xd6,
    0xa5, 0x1c, 0xf3, 0x99, 0x1c, 0x89, 0xf0, 0x4f, 0x3e, 0x8a, 0xe0, 0x93, 0x8a, 0x82, 0xe9, 0x23,
    0x08, 0x13, 0xc5, 0x6e, 0x4e, 0x1f, 0xfb, 0xa5, 0x73, 0xa5, 0xfb, 0x19, 0x20, 0x83, 0x29, 0x2d,
    0x52, 0x67, 0x53, 0x58, 0xa6, 0x6e, 0x42, 0xa2, 0x3a, 0x22, 0x8e, 0xb9, 0x41, 0xd2, 0x7e, 0x8e,
    0xd9, 0x33, 0x65, 0xc3, 0x47, 0xa8, 0x3e, 0xf9, 0x74, 0x99, 0x07, 0x5f, 0x2b, 0x2b, 0x72, 0xcc,
    0x44, 0x22, 0x65, 0x09, 0x11, 0xc2, 0x57, 0x6e, 0xd6, 0x0c, 0x16, 0x8c, 0x19, 0x70, 0x3f, 0x7a,
    0x05, 0x27, 0x44, 0x92, 0x50, 0x6e, 0x4f, 0xb7, 0x70, 0x65, 0x1b, 0xfd, 0xdc, 0x19, 0xaf, 0x51,
    0xaf, 0xa7, 0x2a, 0x81, 0x4d, 0x83, 0xb6, 0x1e, 0xc6, 0xb5, 0x31, 0x96, 0x60, 0xaf, 0x5e, 0x90,
    0x97, 0xe4, 0x78
};

static uint8_t sha_256_835_bytes_digest[SHA256_DIGEST_LEN_BYTES] = {
    0xF3, 0x37, 0x1F, 0xF2, 0x85, 0xE5, 0xCA, 0x22, 0x6B, 0x59, 0xD3, 0xCF, 0x47, 0x20, 0x2D, 0x99,
    0x7C, 0x01, 0x8E, 0x90, 0x55, 0x5D, 0x23, 0x12, 0x5E, 0x7F, 0xD1, 0xBE, 0x96, 0x24, 0x38, 0x73
};
  
static const TEST_VECTOR sha_256_835_bytes_vector = {
    (uint8_t*) &sha_256_835_bytes, 
    sizeof(sha_256_835_bytes),
    (uint8_t*) &sha_256_835_bytes_digest
};

TEST_VECTOR sha_256_test_vectors[NUMBER_OF_SHA256_VECTORS] = {
    [0] = sha_256_0_bytes_vector,
    [1] = sha_256_35_bytes_vector,
    [2] = sha_256_41_bytes_vector,
    [3] = sha_256_48_bytes_vector,
    [4] = sha_256_64_bytes_vector,
    [5] = sha_256_128_bytes_vector,
    [6] = sha_256_512_bytes_vector,
    [7] = sha_256_835_bytes_vector,
};